package software.project;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.BitmapFactory.Options;
import android.graphics.Color;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.os.PowerManager;
import android.os.PowerManager.WakeLock;
import android.util.DisplayMetrics;
import android.util.Log;
import android.view.Display;
import android.view.Surface;
import android.view.View;
import android.view.WindowManager;
import software.project.R;


public class BalleActivity extends Activity {

    private SimulationView mSimulationView;
    private SensorManager mSensorManager;
    private PowerManager mPowerManager;
    private WindowManager mWindowManager;
    private Display mDisplay;
    private WakeLock mWakeLock;
    
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);       
        // Get an instance of the SensorManager
        mSensorManager = (SensorManager) getSystemService(SENSOR_SERVICE);

        // Get an instance of the PowerManager
        mPowerManager = (PowerManager) getSystemService(POWER_SERVICE);

        // Get an instance of the WindowManager
        mWindowManager = (WindowManager) getSystemService(WINDOW_SERVICE);
        mDisplay = mWindowManager.getDefaultDisplay();

        // Create a bright wake lock
        mWakeLock = mPowerManager.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, getClass()
                .getName());

        // instantiate our simulation view and set it as the activity's content
        mSimulationView = new SimulationView(this);
        setContentView(mSimulationView);
    }

//    private MotionEvent onTouchEvent(int actionDown) {
//		// TODO Auto-generated method stub
//		return null;
//	}

	@Override
    protected void onResume() {
        super.onResume();
        /*
         * when the activity is resumed, we acquire a wake-lock so that the
         * screen stays on, since the user will likely not be fiddling with the
         * screen or buttons.
         */
        mWakeLock.acquire();

        // Start the simulation
        mSimulationView.startSimulation();
    }

    @Override
    protected void onPause() {
        super.onPause();
        /*
         * When the activity is paused, we make sure to stop the simulation,
         * release our sensor resources and wake locks
         */

        // Stop the simulation
        mSimulationView.stopSimulation();

        // and release our wake-lock
        mWakeLock.release();
    }

    class SimulationView extends View implements SensorEventListener {
        // diameter of the balls in meters
        private static final float sBallDiameter = 0.0025f;
        private Particle mBall;

        // friction of the virtual table and air
        private static final float sFriction = 0.8f;

        private Sensor mAccelerometer;
        private long mLastT;
        private float mLastDeltaT;

        private float mXDpi;
        private float mYDpi;
        private float mMetersToPixelsX;
        private float mMetersToPixelsY;
        private Bitmap mBitmap;
        private Bitmap mWood;
        private MoscaJodona mosca;
        private Spider Spider;
        private Ratita Rat;
        
        private Bitmap mFly;
        private Bitmap mSpider;
        private Bitmap mRat;
        
        private DisplayMetrics metrics;
        private float mXOrigin=0;
        private float mYOrigin=0;
        private float mSensorX;
        private float mSensorY;
        private long mSensorTimeStamp;
        private long mCpuTimeStamp;
        private float mHorizontalBound;
        private float mVerticalBound;
        private final ParticleSystem mParticleSystem = new ParticleSystem();

        /*Each of our particle holds its previous and current position, its
         * acceleration. for added realism each particle has its own friction
         * coefficient.*/
        class Particle {
            private float mPosX;
            private float mPosY;
            private float mAccelX;
            private float mAccelY;
            private float mLastPosX;
            private float mLastPosY;
            private float mOneMinusFriction;

            Particle() {
                // make the particle a bit different by randomizing its coefficient of friction
                final float r = ((float) Math.random() - 0.5f) * 0.2f;
                mOneMinusFriction = 1.0f - sFriction + r;
            }

            public void computePhysics(float sx, float sy, float dT, float dTC) {
                // Force of gravity applied to our virtual object
                final float m = 1000.0f; // mass of our virtual object
                final float gx = -sx * m;
                final float gy = -sy * m;

                 /* �F = mA <=> A = �F / m We could simplify the code by
                 * completely eliminating "m" (the mass) from all the equations,
                 * but it would hide the concepts from this sample code.*/
                final float invm = 1.0f / m;
                final float ax = gx * invm;
                final float ay = gy * invm;

                /* Time-corrected Verlet integration The position Verlet
                 * integrator is defined as x(t+�t) = x(t) + x(t) - x(t-�t) +
                 * a(t)�t�2 However, the above equation doesn't handle variable
                 * �t very well, a time-corrected version is needed: x(t+�t) =
                 * x(t) + (x(t) - x(t-�t)) * (�t/�t_prev) + a(t)�t�2 We also add
                 * a simple friction term (f) to the equation: x(t+�t) = x(t) +
                 * (1-f) * (x(t) - x(t-�t)) * (�t/�t_prev) + a(t)�t�2*/
                final float dTdT = dT * dT;
                float x = mPosX + mOneMinusFriction * dTC * (mPosX - mLastPosX) + mAccelX * dTdT;
                float y = mPosY + mOneMinusFriction * dTC * (mPosY - mLastPosY) + mAccelY * dTdT;
                
                float dPixlsX;
    			float dPixlsY;
    			
                mLastPosX = x;
                mLastPosY = y;
//                Log.v("VALORES", "Inicial("+mPosX+", "+mPosY+") Final("+mLastPosX+", "+mLastPosY+")");
////
//                dPixlsX = (mLastPosX) -(mPosX);
//                dPixlsY = (mLastPosY) -(mPosY);
////                Log.v("VALORES", dPixlsX+", "+dPixlsY);
//              
//                if(dPixlsX<0){		//Colision a la izquierda
////              	Log.v("COLISION","IZQUIERDA");
//	              	for(int i= (int) mPosX; i>mLastPosX; i--){
//	              		if(dPixlsY<0){
////	                      	Log.v("COLISION","ARRIBA");
//	                      	for(int j=(int)mPosY;j>mLastPosY;j--){
//    	              			Log.v("COLLITION","COLOR: "+mWood.getPixel(i, j));
//	                      		if(mWood.getPixel(i, j) == Color.BLACK){
//	    	              			x=i+1;	y=j+1;
//	    	              			break;
//	    	              		}
//	                      	}
//	              		}
//	              		
//	              		if(dPixlsY+25>0){
////	                      	Log.v("COLISION","ARRIBA");
//	                      	for(int j=(int)mPosY;j>mLastPosY;j++){
//	                      		if(mWood.getPixel(i, j) == Color.BLACK){
////	    	              			Log.v("COLLITION","EXISTE COLISION IZQUIERDA");
//	    	              			x=i+1;	y=j-1;
//	    	              			break;
//	    	              		}
//	                      	}
//	              		}
//	              	}
//                }
//                if(dPixlsX+25>0){		//Colision a la derecha
////              	Log.v("COLISION", "DERECHA");
//	              	for(int i= (int) mPosX; i>mLastPosX; i++){
//	              		if(dPixlsY<0){
////	                      	Log.v("COLISION","ARRIBA");
//	                      	for(int j=(int)mPosY;j>mLastPosY;j--){
//	                      		if(mWood.getPixel(i, j) == Color.BLACK){
////	    	              			Log.v("COLLITION","EXISTE COLISION IZQUIERDA");
//	    	              			x=i-1;	y=j+1;
//	    	              			break;
//	    	              		}
//	                      	}
//	              		}
//	              		
//	              		if(dPixlsY+25>0){
////	                      	Log.v("COLISION","ARRIBA");
//	                      	for(int j=(int)mPosY;j>mLastPosY;j++){
//	                      		if(mWood.getPixel(i, j) == Color.BLACK){
////	    	              			Log.v("COLLITION","EXISTE COLISION IZQUIERDA");
//	    	              			x=i+1;	y=j-1;
//	    	              			break;
//	    	              		}
//	                      	}
//	              		}
//	              	}
//                }
//                
//                else
////                	Log.v("NO COLISIONA","NO HAY DIFERENCIA EN MOVIMIENTO");
//                
                mPosX = mLastPosX;
                mPosY = mLastPosY;
                mAccelX = ax;
                mAccelY = ay;
            }

            public void resolveCollisionWithWalls(int x, int y){
            	
            }
            
            /* Resolving constraints and collisions with the Verlet integrator
             * can be very simple, we simply need to move a colliding or
             * constrained particle in such way that the constraint is
             * satisfied.*/
            public void resolveCollisionWithBounds() {
                final float xmax = mHorizontalBound;
                final float ymax = mVerticalBound;                
                final float x = mPosX;
                final float y = mPosY;

                if (x > xmax) {							//Manejan Coordenadas cartesianas y no en pixeles como yo pensaba
                    mPosX = xmax;
                } else if (x < 0) {
                    mPosX = 0;
                }
                	
                if (y > 0) {					
                    mPosY = 0;
                } else if (y < -ymax) {
                    mPosY = -ymax;
                }
                
              //Revisa colisiones con el mapa (paredes del laberinto)
                
//                if(mWood.getPixel((int)x, (int)y-1)== Color.BLACK)
//                	mPosY=y;
//                if(mWood.getPixel((int)x+1, (int)y)== Color.BLACK)
//                	mPosX=x;
//                if(mWood.getPixel((int)x, (int)y+1)== Color.BLACK)
//                	mPosY=y;
                
            }
        }
        

        /* the particle system is just a collection of particles*/
        class ParticleSystem {
        	
            ParticleSystem() {
                    mBall = new Particle();
            }

           
           
            /** Update the position of each particle in the system using the Verlet integrator.**/
            private void updatePositions(float sx, float sy, long timestamp) {
                final long t = timestamp;
                if (mLastT != 0) {
                    final float dT = (float) (t - mLastT) * (1.0f / 1000000000.0f);
                    if (mLastDeltaT != 0) {
                        final float dTC = dT / mLastDeltaT;
                        Log.v("REALIZA FISICA","");
                        mBall.computePhysics(sx, sy, dT, dTC);                        
                    }
                    mLastDeltaT = dT;
                }
                mLastT = t;
            }

            /* Performs one iteration of the simulation. First updating the
             * position of all the particles and resolving the constraints and
             * collisions.*/
            public void update(float sx, float sy, long now) {
                // update the system's positions
//            	Log.v("UPDATE","updatePositions");
                updatePositions(sx, sy, now);

                // We do no more than a limited number of iterations
                final int NUM_MAX_ITERATIONS = 100;

                /*Resolve collisions, each particle is tested against every
                 * other particle for collision. If a collision is detected the
                 * particle is moved away using a virtual spring of infinite
                 * stiffness.*/
                boolean more = true;
                for (int k = 0; k < NUM_MAX_ITERATIONS && more; k++) {
                    more = false;
                    Particle curr = mBall;
                        curr.resolveCollisionWithBounds();
                    
                }
            }
            
            public float getmLastPosX() {
                return mBall.mLastPosX;
            }
            
            public float getmLastPosY() {
                return mBall.mLastPosY;
            }
            
            public float getPosX() {
                return mBall.mPosX;
            }
          
            public float getPosY() {
                return mBall.mPosY;
            }
        }

        public void startSimulation() {
            /*It is not necessary to get accelerometer events at a very high
             * rate, by using a slower rate (SENSOR_DELAY_UI), we get an
             * automatic low-pass filter, which "extracts" the gravity component
             * of the acceleration. As an added benefit, we use less power and
             * CPU resources.*/
            mSensorManager.registerListener(this, mAccelerometer, SensorManager.SENSOR_DELAY_UI);
        }

        public void stopSimulation() {
            mSensorManager.unregisterListener(this);
        }

        public SimulationView(Context context) {
            super(context);
            mAccelerometer = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);

            metrics = new DisplayMetrics();
            getWindowManager().getDefaultDisplay().getMetrics(metrics);
            mXDpi = metrics.xdpi;
            mYDpi = metrics.ydpi;
            mMetersToPixelsX = mXDpi / 0.0254f;
            mMetersToPixelsY = mYDpi / 0.0254f;

            // rescale the ball so it's about 0.5 cm on screen
            Bitmap ball = BitmapFactory.decodeResource(getResources(), R.drawable.ball);
            final int dstWidth = (int) (sBallDiameter * mMetersToPixelsX + 0.5f);
            final int dstHeight = (int) (sBallDiameter * mMetersToPixelsY + 0.5f);
            
            //Crea los enemigos.
            mosca	 = new MoscaJodona(BitmapFactory.decodeResource(getResources(), R.drawable.moscajodona), metrics);
            Spider 	 = new Spider(BitmapFactory.decodeResource(getResources(), R.drawable.arania), metrics);
    		Rat		 = new Ratita(BitmapFactory.decodeResource(getResources(), R.drawable.ratita), metrics);
    		
    		//Carga los bitmaps de los enemigos.
    		mFly 	= mosca.getBitmap();
    		mSpider = Spider.getBitmap();
    		mRat	= Rat.getBitmap();
    		

            mBitmap = Bitmap.createScaledBitmap(ball, dstWidth, dstHeight, true);
            Options opts = new Options();
            opts.inDither = true;
            opts.inPreferredConfig = Bitmap.Config.RGB_565;
            mWood = BitmapFactory.decodeResource(getResources(), R.drawable.vertical, opts);	
        }

        protected void onSizeChanged(int w, int h, int oldw, int oldh) {			//NO SE UTILIZA
            // compute the origin of the screen relative to the origin of
//            // the bitmap
//          mXOrigin = (0 - mBitmap.getWidth()) * 0.5f;
//          mYOrigin = (0 - mBitmap.getHeight()) * 0.5f;
            mHorizontalBound = ((w / mMetersToPixelsX - sBallDiameter) * 1f);
            mVerticalBound = ((h / mMetersToPixelsY - sBallDiameter) * 1f);
        }

        public void onSensorChanged(SensorEvent event) {
            if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER)
                return;
            
            /*Record the accelerometer data, the event's timestamp as well as
             * the current time. The latter is needed so we can calculate the
             * "present" time during rendering. In this application, we need to
             * take into account how the screen is rotated with respect to the
             * sensors (which always return data in a coordinate space aligned
             * to with the screen in its native orientation).
             */

            switch (mDisplay.getRotation()) {
                case Surface.ROTATION_0:
                    mSensorX = event.values[0];
                    mSensorY = event.values[1];
                    break;
                case Surface.ROTATION_90:
                    mSensorX = -event.values[1];
                    mSensorY = event.values[0];
                    break;
                case Surface.ROTATION_180:
                    mSensorX = -event.values[0];
                    mSensorY = -event.values[1];
                    break;
                case Surface.ROTATION_270:
                    mSensorX = event.values[1];
                    mSensorY = -event.values[0];
                    break;
            }

            mSensorTimeStamp = event.timestamp;
            mCpuTimeStamp = System.nanoTime();
        }
        float angle =0;
        @Override
        protected void onDraw(Canvas canvas) {										//METODO SIMILAR AL PAINT();
//        	Log.v("DIBUJADO","onDRAW");
            /*draw the background*/
            canvas.drawBitmap(mWood, 10, 10, null);
            
            /*compute the new position of our object, based on accelerometer data and present time.*/
            final ParticleSystem particleSystem = mParticleSystem;
            final long now = mSensorTimeStamp + (System.nanoTime() - mCpuTimeStamp);
            final float sx = mSensorX;
            final float sy = mSensorY;
            
            particleSystem.update(sx, sy, now);
            
            final float xc = mXOrigin;
            final float yc = mYOrigin;
            final float xs = mMetersToPixelsX;
            final float ys = mMetersToPixelsY;
            final Bitmap bitmap = mBitmap;
            final Bitmap fly 	= mFly;
            final Bitmap spider = mSpider;
            final Bitmap rat 	= mRat;
            
            /*We transform the canvas so that the coordinate system matches the sensors coordinate system with the origin in the center
             of the screen and the unit is the meter.*/
            float x = xc + particleSystem.getPosX() * xs;
            float y = yc - particleSystem.getPosY() * ys;
            float xA = xc + Spider.getPosX();
            float yA = yc + Spider.getPosY();
            float xR = xc + Rat.getPosX();
            float yR = yc + Rat.getPosY();
            float xF = xc + mosca.getPosX();
            float yF = yc + mosca.getPosY();
            
            mosca.UpdatePositions(x, y);
            Spider.UpdatePositions(metrics);
            Rat.UpdatePositions(metrics);
            
            Paint paint = new Paint();
            canvas.drawBitmap(bitmap, x, y, null);
            canvas.drawText("X: "+x , x, y-15, paint);
            canvas.drawText("Y: "+y , x, y-3, paint);
            
            canvas.drawBitmap(fly, xF, xF, null);
            
            canvas.drawBitmap(spider, xA, yA, null);
            
            canvas.drawBitmap(rat, xR, yR, null);
            
            // and make sure to redraw asap
            invalidate();
        }

        public void onAccuracyChanged(Sensor sensor, int accuracy) {				//NO SE UTILIZA
        	
        }
    }
}